home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume3 / texchk / part1 next >
Encoding:
Internet Message Format  |  1986-11-30  |  37.2 KB
  1. From: talcott!think!massar
  2. Subject: texchk (part 1 of 2) - syntax checker for LaTeX
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 63
  7. Submitted by: talcott!think!massar
  8.  
  9.  
  10. This is 'texchk', a syntax checker for the LaTeX TeX macro package.
  11.  
  12. JP Massar
  13. massar@think.com
  14. ihnp4!think!massar
  15.  
  16. ------------------------------------------------------------------------------
  17. #! /bin/sh
  18. # This is a shell archive, meaning:
  19. # 1. Remove everything above the #! /bin/sh line.
  20. # 2. Save the resulting text in a file.
  21. # 3. Execute the file with /bin/sh (not csh) to create the files:
  22. #    README
  23. #    Makefile
  24. #    texchk.1
  25. #    cmds.h
  26. #    ctools.h
  27. #    texchars.h
  28. #    texchk.h
  29. #    texchk.c
  30. # This archive created: Tue Dec 17 09:59:40 1985
  31. export PATH; PATH=/bin:$PATH
  32. echo shar: extracting "'README'" '(1687 characters)'
  33. if test -f 'README'
  34. then
  35.     echo shar: will not over-write existing file "'README'"
  36. else
  37. cat << \SHAR_EOF > 'README'
  38. Instructions for installing texchk:
  39.  
  40.   Assuming you are running a BSD 4.2 or compatible system:
  41.  
  42.     Edit the file Makefile.
  43.          Change the BIN variable to the directory where you want the
  44.            executable to go.
  45.          Change the MS variable to be the 'x' which makes /usr/man/manx
  46.            acceptable to you.
  47.          Change the CC variable if you wish to compile with other than 'cc'.
  48.     Type 'make install -n' to insure that you understand what is
  49.       happening.
  50.     Type 'make install'.
  51.     Type 'make man'.
  52.     Type 'texchk -c -v <your-own-latex-file>' and verify that it is
  53.       producing reasonable output.
  54.     Type 'make clean'.
  55.  
  56.   Assuming you are on a non BSD 4.2 compatible system:
  57.  
  58.     You will probably have to change the call to 'rindex' in ctools.c.
  59.     (Compiling with "-Drindex=strrchr" is sufficient - see the Makefile).
  60.  
  61.     If your compiler is brain damaged you may have to extensively    
  62.       shorten and revise the names of various variables and preprocessor
  63.       constants.
  64.  
  65.     Take out the -DBSD42 flag from the Makefile.  If your system does
  66.     not have <string.h> (Berkeley called it strings.h), you may have
  67.     to edit ctools.c and texchk.c to declare the strxxx functions.
  68.  
  69.     Modulo these changes, I got texchk to run under BRL's SYSTEM V
  70.       emulation package so hopefully it will run on most systems.
  71.  
  72.  
  73. The files ctools.c and ctools.h are potentially useful in their own 
  74. right.  They contain a library of routines I find or found useful.  You
  75. might look through it for functions you will find useful or you could
  76. install the whole thing as a library as has been done here at TMC.
  77.  
  78. JP Massar
  79. massar@think.com
  80. ihnp4!think!massar
  81. SHAR_EOF
  82. if test 1687 -ne "`wc -c < 'README'`"
  83. then
  84.     echo shar: error transmitting "'README'" '(should have been 1687 characters)'
  85. fi
  86. fi
  87. echo shar: extracting "'Makefile'" '(592 characters)'
  88. if test -f 'Makefile'
  89. then
  90.     echo shar: will not over-write existing file "'Makefile'"
  91. else
  92. cat << \SHAR_EOF > 'Makefile'
  93. CC = cc
  94.  
  95. #use the following DEFINES line for non-BSD systems
  96. #DEFINES = -Drindex=strchr
  97. DEFINES = -DBSD42
  98.  
  99. #use the following CFLAGS line for debugging
  100. #CFLAGS = -g $(DEFINES)
  101. CFLAGS = -O $(DEFINES)
  102.  
  103. SOURCES = texchk.c cmds.c texchars.c errors.c verbatim.c ctools.c
  104. OBJECTS = texchk.o cmds.o texchars.o errors.o verbatim.o ctools.o
  105. LIBS =
  106. BIN = /usr/local
  107. MS=1
  108. MAN = /usr/man/man$(MS)
  109.  
  110. texchk: $(OBJECTS)
  111.     $(CC) -o texchk $(CFLAGS) $(OBJECTS) $(LIBS)
  112. install: texchk
  113.     rm -f $(BIN)/texchk
  114.     mv texchk $(BIN)/texchk
  115. man: 
  116.     cp texchk.1 $(MAN)/texchk.$(MS)
  117.     man texchk
  118. clean:
  119.     rm -f texchk *.o *~
  120. SHAR_EOF
  121. if test 592 -ne "`wc -c < 'Makefile'`"
  122. then
  123.     echo shar: error transmitting "'Makefile'" '(should have been 592 characters)'
  124. fi
  125. fi
  126. echo shar: extracting "'texchk.1'" '(2494 characters)'
  127. if test -f 'texchk.1'
  128. then
  129.     echo shar: will not over-write existing file "'texchk.1'"
  130. else
  131. cat << \SHAR_EOF > 'texchk.1'
  132. .TH TEXCHK 1 3/13/85
  133. .SH NAME
  134. TEXCHK - syntax checker for LaTeX.
  135. .SH SYNOPSIS
  136. .B texchk
  137. [ -v -c ] [ file1 file2 ... ]
  138. .SH DESCRIPTION
  139. By default
  140. .I texchk 
  141. reads from standard input and outputs error messages and whatnot to
  142. standard error.  If filenames are given as arguments, each file is read
  143. and parsed in turn.
  144. .PP
  145. .I texchk
  146. checks for the proper nesting of matching '{' '}' and '[' ']' pairs,
  147. matching '\\begin{<environment>}' '\\end{<environment>} pairs, and Math Mode
  148. and Display Math Mode constructs.  If improper nesting is detected, an error
  149. message consisting of a reason, a line number, and the actual line of text
  150. on which the error occurred is displayed.
  151. .PP
  152. In general, the program will halt after finding and printing the first
  153. error, because attempts at further diagnosis would likely result in a
  154. stream of spurious error messages.  
  155. .PP
  156. Unlike LaTeX
  157. .I texchk
  158. is fast.  It can grovel over a large file in a matter of a few seconds,
  159. and can be run repeatedly without causing the CPU to beg for mercy.
  160. .PP
  161. The command line options are:
  162. .TP
  163. .B \-v
  164. Verbose option.  Produces on the standard output a trace of each environment
  165. .I texchk 
  166. enters and leaves, along with the number of the line it is currently 
  167. processing.  This is used basically to assure yourself that
  168. .I texchk
  169. is actually doing something, if you give it a huge file to process.
  170. (And is mildly interesting).
  171. .TP
  172. .B \-c
  173. Check mode.  Tells
  174. .I texchk
  175. to check each keyword (e.g., \\hspace, \\mbox) in the file against a list of 
  176. known keywords, and issue a warning if the keyword is not in the list.
  177. Also, each keyword is checked as to whether it is only legal if given 
  178. inside of math mode, and if so and if math mode is not enabled, an error
  179. message is given (but processing continues).
  180. .SH FILES
  181. /usr/src/local/cmd/texchk        source directory.
  182. .br
  183. /usr/local/texchk            executable image.
  184. .SH AUTHOR
  185. JP Massar, Thinking Machines Corporation
  186. .SH BUGS
  187. .I texchk
  188. makes no claims to being perfect.  It is quite possible that an 'error'
  189. flagged by
  190. .I texchk
  191. is not really an error at all if run through LaTeX.
  192. .PP
  193. It does not check for number of arguments, presence of optional arguments,
  194. etc.
  195. .PP
  196. It does not know that certain keywords can only be used in certain modes.
  197. .PP
  198. It does not understand that '[' and ']' can be used in regular text
  199. without necessarily being paired. Also, \\left], for example,
  200. will confuse it totally.
  201. .PP
  202. Although not officially part of LaTeX, 
  203. .I texchk
  204. understands the '$$' construct of TeX.
  205. SHAR_EOF
  206. if test 2494 -ne "`wc -c < 'texchk.1'`"
  207. then
  208.     echo shar: error transmitting "'texchk.1'" '(should have been 2494 characters)'
  209. fi
  210. fi
  211. echo shar: extracting "'cmds.h'" '(803 characters)'
  212. if test -f 'cmds.h'
  213. then
  214.     echo shar: will not over-write existing file "'cmds.h'"
  215. else
  216. cat << \SHAR_EOF > 'cmds.h'
  217. typedef struct {
  218.  
  219.    int cmdlength;
  220.    char *cmd;
  221.    char is_math_mode_only;
  222.    unsigned flags;
  223.  
  224.  } Latex_Command, *Ptr_Latex_Command;
  225.  
  226.  
  227. extern Latex_Command Command_Table[]; 
  228.  
  229. extern char *Math_Environments[];
  230.  
  231. #define COMMAND_TABLE_SIZE (sizeof(Command_Table)/sizeof(Latex_Command))
  232.  
  233. #define IS_MATH_MODE(i) (Command_Table[(i)].is_math_mode_only)
  234.  
  235. #define NOT_FOUND -1 
  236.  
  237. extern int command_lookup ();
  238.  
  239.   /* ARGUMENTS:
  240.      char *command;
  241.   */
  242.  
  243.   /* 'command' is the name of a presumed latex command, including the */
  244.   /* initial backslash.   Returns NOT_FOUND if command is not in the command */
  245.   /* table, otherwise the index into the command table of the entry for */
  246.   /* the input command. */
  247.  
  248. extern int is_math_environment();
  249.  
  250.   /* ARGUMENTS:
  251.      char *keyword;
  252.   */
  253.  
  254.   /* Returns 1 or 0 */
  255. SHAR_EOF
  256. if test 803 -ne "`wc -c < 'cmds.h'`"
  257. then
  258.     echo shar: error transmitting "'cmds.h'" '(should have been 803 characters)'
  259. fi
  260. fi
  261. echo shar: extracting "'ctools.h'" '(10814 characters)'
  262. if test -f 'ctools.h'
  263. then
  264.     echo shar: will not over-write existing file "'ctools.h'"
  265. else
  266. cat << \SHAR_EOF > 'ctools.h'
  267. /* -*- Mode: C; Package: (CTOOLS C) -*- */
  268.  
  269. #ifndef Bool
  270. #define Bool int
  271. #endif
  272.  
  273. #ifndef T
  274. #define T 1
  275. #endif
  276.  
  277. #ifndef F
  278. #define F 0
  279. #endif
  280.  
  281. #ifndef MAXINT
  282. #define MAXINT 2147483647
  283. #define MAXINTSTR "2147483647"
  284. #endif
  285.  
  286. #ifndef MAXPATHLEN
  287. #define MAXPATHLEN 80
  288. #endif
  289.  
  290. extern char *emalloc();
  291.  
  292.   /* int space; */
  293.   /* space must be greater than 0 */
  294.   /* Causes executution to halt with a 'Fatal error' message if memory */
  295.   /* cannot be allocated, otherwise returns pointer to malloc-ed space */
  296.  
  297. extern char *anewstr();
  298.  
  299.   /* char *astring; */
  300.   /* emalloc's space and copies astring into that space.  Returns pointer */
  301.   /* to new string. */
  302.  
  303.  
  304. extern int copy();
  305.  
  306.   /* char *dest, *src; int n; */
  307.   /* copies exactly n bytes. */
  308.   /* return value undefined.  Use only as procedure. */
  309.  
  310. extern int fill();
  311.  
  312.   /* char *addr, ch; int n; */
  313.   /* copies ch into n consecutive bytes. */
  314.   /* return value undefined.  Use only as procedure. */
  315.  
  316. extern int to_upper_if_lower();
  317.  
  318.   /* char ch;  Returns possibly upper-cased value. */
  319.  
  320. extern int to_lower_if_upper();
  321.  
  322.   /* char ch;  Returns possibly lower-cased value. */
  323.  
  324. extern int buffconcat();
  325.  
  326.   /* char *buffer, *s1, *s2; */
  327.   /* s1 and s2 must be null terminated.  Buffer must be at least */
  328.   /* strlen(s1) + strlen(s2) + 1 characters long.  Buffer is null */
  329.   /* terminated upon completion. */
  330.  
  331.   /* return value undefined.  Use only as procedure. */
  332.  
  333. extern int nbuffconcat();
  334.  
  335.   /* char *buffer; int n; char *s1,*s2,*s3,*s4,*s5,*s6; */
  336.   /* all the strings must be null terminated.  Buffer must be big enough */
  337.   /* to hold the null terminated result.  0 < n < 7 . 
  338.   /* returns -1 if n is out of range, otherwise 0 */
  339.  
  340. extern int slcompare();
  341.  
  342.   /* char *s1; int l1; char *s2; int l2 */
  343.   /* does not stop if it encounters a null character. */
  344.   /* returns 0 if equal, -1 if not equal */
  345.  
  346. extern int slge_compare();
  347.  
  348.   /* char *s1; int l1; char *s2; int l2 */
  349.   /* does not stop if it encounters a null character. */
  350.   /* returns 0 if equal, -1 if s1 < s2, 1 if s1 > s2 */
  351.  
  352. extern int nocase_compare();
  353.  
  354.   /* char *s1; int l1; char *s2; int l2 */
  355.   /* does not stop if it encounters a null character. */
  356.   /* returns 0 if equal, -1 if s1 < s2, 1 if s1 > s2  case independently. */
  357.  
  358. extern char * strfind();
  359.  
  360.   /* char *s1; char *s2; int fast; */
  361.   /* finds s2 as a substring of s1.  s1 and s2 are null terminated. */
  362.   /* returns 0 if not found, otherwise pointer into s1 to first matching */
  363.   /* character. */
  364.  
  365.   /* WARNING:  will access off the end of s1 in the interest of efficiency */
  366.   /* if 'fast' is non-zero. */
  367.  
  368. extern char * strncfind();
  369.  
  370.   /* char *s1; char *s2; int fast; */
  371.   /* finds s2 as a substring of s1 case independently.  s1 and s2 are */
  372.   /* null terminated. */
  373.   /* returns 0 if not found, otherwise pointer into s1 to first matching */
  374.   /* character. */
  375.  
  376.   /* WARNING:  will access off the end of s1 in the interest of efficiency */
  377.   /* if 'fast' is non-zero. */
  378.  
  379. extern char * strsearch();
  380.  
  381.   /* char *s1; int l1; char *s2; int l2 */
  382.   /* finds s2 as a substring of s1.  Does not stop if it encounters a null. */
  383.   /* returns pointer into s1, otherwise (char *) 0 if search fails */
  384.   /* case dependent */
  385.  
  386. extern char * strncsearch();
  387.  
  388.   /* char *s1; int l1; char *s2; int l2 */
  389.   /* finds s2 as a substring of s1. */
  390.   /* returns pointer into s1, otherwise (char *) 0 if search fails */
  391.   /* case independent */
  392.  
  393. extern int remove_excess_blanks();
  394.  
  395.   /* char *newstring, *oldstring; */
  396.   /* newstring must be long enough to hold the result, which may be as */
  397.   /* long as oldstring.  oldstring must be null terminated. */
  398.   /* an excess blank is any blank before the first non-blank character, */
  399.   /* any blank after the last non-blank character, and any blank immediately */
  400.   /* following a blank. */
  401.   /* returns length of newstring */
  402.  
  403. extern int yes_or_no_check();
  404.  
  405.   /* char *astring; */
  406.   /* returns 1 for yes, 0 for no, -1 for neither. */
  407.   /* astring must be one of "YES", "Y", "NO", "N" in any capitalization. */
  408.  
  409.  
  410. /* These routines return T if every char satisfies a certain condition. */
  411. /* These returns all returns T if given a null string. */
  412.  
  413. extern Bool all_digits();
  414. extern Bool all_whitespace();
  415. extern Bool all_uppercase();
  416. extern Bool all_lowercase();
  417. extern Bool all_alphabetic();
  418. extern Bool all_alphanumeric();
  419. extern Bool all_ascii();
  420.  
  421.  
  422. extern int str_to_pos_int();
  423.  
  424.   /* char *astring; int low,high; */
  425.   /* low must be >= 0. */
  426.   /* returns -1 if *astring is not composed of digits. */
  427.   /* returns -2 if the integer is out of range. */
  428.   /* despite its name, 0 can be returned as a legitimate value. */
  429.   /* treats all digit strings as decimal. */
  430.  
  431.  
  432. extern int sreverse();
  433.  
  434.   /* char *buffer; char *astring; */
  435.   /* puts the characters of astring in reverse order into buffer. */
  436.   /* buffer must be at least as long as astring + 1. */
  437.   /* buffer is null terminated when done. */
  438.   /* No return value.  Use only as procedure. */
  439.  
  440. extern char *ip_sreverse();
  441.  
  442.   /* char *astring; */
  443.   /* Returns astring with its characters reversed. */
  444.   /* reversal is done in place. */
  445.  
  446.  
  447.  
  448. #define PATH_MAXPATHLEN 256
  449.  
  450. char *temp_path();
  451.  
  452. /*
  453.   char *dir; char *filename;
  454.  
  455.   Returns a pointer to a character string containing the string
  456.   <dir>/<filename>.  The pointer points to a buffer which will may get
  457.   overwritten if any functions in this package are subsequently called.
  458.   0 is returned if the pathname would exceed PATH_MAXPATHLEN-1 chars.
  459. */
  460.  
  461.  
  462. char *perm_path();
  463.  
  464. /*
  465.   char *dir; char *filename;
  466.  
  467.   Same as temp_path, except the pathname string is malloc'ed and is thus
  468.   permanent unless specifically freed by the user.  Further, no limit
  469.   on the size of the path is made.
  470. */
  471.  
  472.  
  473. char *make_path();
  474.  
  475. /*
  476.   char *dir; char *filename; char *extension; Bool perm;
  477.  
  478.   Creates <dir>/<filename><extension> .  The string returned is permanent
  479.   or not depending on 'perm'.  If perm is not true, 0 will be returned if
  480.   the resulting path exceeds PATH_MAXPATHLEN-1 chars.
  481. */
  482.  
  483.  
  484. char *make_path_numeric_extension();
  485.  
  486. /*
  487.   char *dir; char *filename; int extension; Bool perm;
  488.  
  489.   Same as make_path except that extension is first converted into a
  490.   string using sprintf.
  491. */
  492.  
  493.  
  494. char *just_filename();
  495.  
  496. /*  
  497.   char *path; Bool new; Bool perm;
  498.  
  499.   Given a path of the form /<x>/<y>/<z> returns <z>.  If new is not set
  500.   then a pointer into the original input string is returned.  If new is
  501.   set a copy is returned, either permanent or not depending on perm.
  502. */
  503.  
  504.  
  505. #define ANSWER_NO 0
  506. #define ANSWER_YES 1
  507. #define ANSWER_HELP 2
  508. #define ANSWER_QUIT 3
  509. #define ANSWER_EOF 4
  510.  
  511. #define AT_EOF -1
  512. #define TOO_MANY_CHARS -2
  513. #define IOERROR -3
  514. #define TOO_MANY_LINES -4
  515. #define LINE_TOO_LONG -5
  516.  
  517. extern read_yes_or_no ();
  518.  
  519.   /* FILE *iport, *oport; char *prompt; char *helpstring; char *quitstring; */
  520.  
  521.   /* prints prompt, then reads from iport until is gets 'Y', 'N', 'YES' or */
  522.   /* 'NO' (case independently).  If helpstring and/or quitstring are not */
  523.   /* "" or (char *) 0 then if the user types in one of those ANSWER_HELP */
  524.   /* or ANSWER_QUIT are returned, otherwise ANSWER_NO or ANSWER_YES are */
  525.   /* eventually returned. */
  526.  
  527.  
  528. extern int getline ();
  529.  
  530.   /* FILE *iport; char *buffer; int buflen; */
  531.  
  532.   /* reads a line into buffer.  Does not put the '\n' into buffer. */
  533.   /* Returns AT_EOF if at end of file when called.  If it encounters */
  534.   /* end of file after reading at least one character, the eof is treated */
  535.   /* as if it were a newline.   Returns TOO_MANY_CHARS if more than */
  536.   /* buflen - 1 characters are read before encountering a newline. */        
  537.   /* In this case exactly buflen - 1 characters are read. */
  538.   /* The last character read is always follwed by a '\0'. */
  539.   /* if successful getline returns the number of characters read exclusive */
  540.   /* of a terminating newline or eof. */
  541.  
  542.  
  543. extern int getlines();
  544.  
  545.   /* FILE *fp; int n; char ***ptr_lines; char *linebuf; int maxlinelen; */
  546.   /* See documentation for getfile below */
  547.   /* If called, 'n' must have a value 0. */
  548.  
  549. extern int getfile();
  550.  
  551.   /* char *filename; char ***ptr_lines; char *linebuf; int maxlinelen; */
  552.  
  553.   /* read in a file as an array of character strings */
  554.   /* 'maxlinelen+1' is the maximum length a line of the file is allowed */
  555.   /* to be.  'linebuf' must be at least 'maxlinelen+1' characters long. */
  556.   /* Returns the number of lines in the file (and therefore the number */
  557.   /* of entries in *ptr_lines) if successful.  Returns IOERROR if it */
  558.   /* could not open the file to read from. Returns TOO_MANY_CHARS if */
  559.   /* it encounters a line longer than 'maxlinelen' characters.  
  560.  
  561.   /* Space for each line is malloc'ed as it is read in and the text for */
  562.   /* the jth line is stored in (*ptr_lines)[j] */
  563.  
  564.   /* Only works for fairly small files as it recurses its way through the */
  565.   /* file and does a lot of malloc-ing.  Use read_file_into_buffer or */
  566.   /* ngetfile for large files. */
  567.  
  568. extern int ngetlines();
  569.  
  570.  /* FILE *fp; int n; char ***ptr_lines; char *linebuf; int maxlinelen; */
  571.  /* Same as getlines, except at most 'n' lines will be read.  Returns */
  572.  /* TOO_MANY_LINES if more than 'n' lines are present. */
  573.  
  574. extern int ngetfile();
  575.  
  576.  /* int n; char *filename; char ***ptr_lines; char *linebuf; int maxlinelen; */
  577.  /* See ngetlines above. */
  578.  
  579. extern int read_file_into_buffer();
  580.  
  581.   /* char *filename; 
  582.      char ***ptr_lines;
  583.      int maxlines;
  584.      char *buffer;
  585.      int buflen;
  586.      char *linebuffer;
  587.      int linebuflen;
  588.   */
  589.  
  590.   /* *ptr_lines should be an array of character string pointers maxlines */
  591.   /* big.  buffer should be an array of characters buflen long.  The routine */
  592.   /* reads lines using getline and stores them into buffer, terminating each */
  593.   /* with a null.  A pointer to the nth line read is stored in *ptr_lines[n] */
  594.   /* Returns IOERROR if it cannot open the file for reading, TOO_MANY_LINES */
  595.   /* if more than maxlines were read in, TOO_MANY_CHARS if buffer is */
  596.   /* filled before end of file is reached, and LINE_TOO_LONG is any line is */
  597.   /* longer than linebuflen.  Returns number of lines read in if successful. */
  598.  
  599. extern char *efopen();  
  600.  
  601.   /* char *filename; char *mode */
  602.  
  603.   /* Actually returns a (FILE *), so one must cast the return value to this */
  604.   /* type.  It doesn't return a (FILE *) explicitly because then to include */
  605.   /* this file one would have to include <stdio.h> explicitly before it. */
  606.   /* The routine simply calls fopen with the same arguments, but prints a */
  607.   /* reasonable error message and calls exit if the call to fopen fails. */
  608.  
  609.  
  610. Bool check_string();
  611.  
  612.   /* char *str; long minlen; long maxlen; */
  613.  
  614.   /* Returns T if str is not 0 and has a length between minlen and maxlen */
  615.   /* inclusived, otherwise returns F. */
  616.  
  617.  
  618. #ifndef check_int
  619. #define check_int(i,minval,maxval) ((i) >= (minval) && (i) <= (maxval))
  620. #endif
  621. SHAR_EOF
  622. if test 10814 -ne "`wc -c < 'ctools.h'`"
  623. then
  624.     echo shar: error transmitting "'ctools.h'" '(should have been 10814 characters)'
  625. fi
  626. fi
  627. echo shar: extracting "'texchars.h'" '(198 characters)'
  628. if test -f 'texchars.h'
  629. then
  630.     echo shar: will not over-write existing file "'texchars.h'"
  631. else
  632. cat << \SHAR_EOF > 'texchars.h'
  633. extern init_legal_chars();
  634.  
  635. extern char Lgl_Chars[];
  636. extern char Lgl_Single_Char_Commands[];
  637.  
  638. #define LGL_CHAR(x) (Lgl_Chars[(x)])
  639. #define LGL_SINGLE_COMMAND_CHAR(x) (Lgl_Single_Char_Commands[(x)])
  640. SHAR_EOF
  641. if test 198 -ne "`wc -c < 'texchars.h'`"
  642. then
  643.     echo shar: error transmitting "'texchars.h'" '(should have been 198 characters)'
  644. fi
  645. fi
  646. echo shar: extracting "'texchk.h'" '(1489 characters)'
  647. if test -f 'texchk.h'
  648. then
  649.     echo shar: will not over-write existing file "'texchk.h'"
  650. else
  651. cat << \SHAR_EOF > 'texchk.h'
  652. /* these are the types of tokens we look for in the input text */
  653.  
  654. typedef enum { 
  655.         
  656.         ESCAPE_BEGIN, ESCAPE_END, ESCAPE_ANY,
  657.         LEFT_SQUARE_BRACKET, RIGHT_SQUARE_BRACKET,
  658.         LEFT_CURLY_BRACKET, RIGHT_CURLY_BRACKET,
  659.         MATH, DOUBLE_MATH, ESCAPE_SINGLE_CHAR
  660.  
  661.     } envtype;
  662.  
  663. /* some of the input tokens cause the LaTeX environment to be 'pushed' */
  664. /* following is the definition of the stack on which these tokens are stored */
  665.     
  666. typedef struct {
  667.    envtype etype;
  668.    char *keyword;
  669.    int linenum;
  670.  } Stack_Entry, *Ptr_Stack_Entry;
  671.  
  672. #define MAX_ENTRIES 10000
  673. #define MAX_KEYWORD_LENGTH 100
  674.  
  675. extern Stack_Entry Lex_Stack[];
  676. extern int Lex_TOS;
  677.  
  678. #define Stack_Empty (Lex_TOS < 0)
  679.  
  680. #define LCB '{'
  681. #define RCB '}'
  682. #define LSB '['
  683. #define RSB ']'
  684. #define MATH_CHAR '$'
  685. #define ESCAPE '\\'
  686. #define COMMENT '%'
  687.  
  688. #define ENDSTRING "end"
  689. #define BEGINSTRING "begin"
  690.  
  691. /* these are the possible actions we can take when we see a token. */
  692. /* the 'CHECK' action has not been implemented. */
  693.  
  694. typedef enum {POP,PUSH,CHECK_SINGLE,DOLLAR,DOLLAR_DOLLAR,CHECK} Actions;
  695.  
  696. /* we keep track of where we are in the text so we can print out nice */
  697. /* error messages */
  698.  
  699. extern long Current_Line, Current_Char;
  700. extern char Line_Buffer[];
  701. #define MAXLL 1024
  702.  
  703. extern Indent_Level;                    /* for verbose pretty print */
  704.  
  705. extern FILE *fp;
  706.  
  707. /* this is LaTeX's definition of whitespace */
  708.  
  709. #define ISWHITE(x) ((x) == ' ' || (x) == '\t')
  710.  
  711. #define SPACES_PER_INDENT_LEVEL 2
  712. SHAR_EOF
  713. if test 1489 -ne "`wc -c < 'texchk.h'`"
  714. then
  715.     echo shar: error transmitting "'texchk.h'" '(should have been 1489 characters)'
  716. fi
  717. fi
  718. echo shar: extracting "'texchk.c'" '(16712 characters)'
  719. if test -f 'texchk.c'
  720. then
  721.     echo shar: will not over-write existing file "'texchk.c'"
  722. else
  723. cat << \SHAR_EOF > 'texchk.c'
  724. /* Texchk -- a LaTeX syntax and spelling checker.
  725.    Written by JP Massar, Thinking Machines Corporation, Cambridge, MA
  726.    This code is hereby released into the public domain, for better or worse.
  727. */
  728.  
  729. #include <stdio.h>
  730. #include <ctype.h>
  731.  
  732. /* if your system doesn't have either string.h or strings.h you */
  733. /* may have to declare the string functions yourself */
  734. #ifdef BSD42
  735. #include <strings.h>
  736. #else
  737. #include <string.h>
  738. #endif
  739.  
  740. #ifdef TMC
  741. #include <ctools.h>
  742. #else
  743. #include "ctools.h"
  744. #endif
  745.  
  746. #include "texchk.h"
  747. #include "cmds.h"
  748. #include "texchars.h"
  749.  
  750. Bool Verbose_Mode = F;                  /* -v option */
  751. Bool Check_Mode = F;                    /* -c option */
  752.  
  753. int Indent_Level = 0;                   /* for verbose output mode */
  754.  
  755. Stack_Entry Lex_Stack[MAX_ENTRIES];     /* environment stack */
  756. int Lex_TOS = -1;
  757.  
  758. FILE *fp;                               /* file being processed */
  759. Bool Already_At_Eof = F;
  760.  
  761. long Current_Line = 0;                  /* where we are in input text */
  762. long Current_Char = 0;                  /* where we are in input text */
  763. long Line_Length = 0;                   /* current line length */
  764. char Line_Buffer[MAXLL];                /* buffer for input text */
  765.  
  766. Bool In_Math_Mode = F;
  767. int Math_Mode_Depth = 0;
  768.  
  769. char Keyword_Buffer[MAX_KEYWORD_LENGTH];
  770.  
  771.  
  772. new_file ()
  773. {
  774.   Current_Line = 0;
  775.   Current_Char = 0;
  776.   Line_Length = 0;
  777.   In_Math_Mode = F;
  778.   Math_Mode_Depth = 0;
  779.   Indent_Level = 0;
  780. }  
  781.         
  782. do_indent (level) int level;
  783. {
  784.   int j,i;
  785.   for (j = 0; j < level; j++)
  786.       for (i = 0; i < SPACES_PER_INDENT_LEVEL; i++) putc(' ',stderr);
  787. }
  788.  
  789.  
  790. lex_push (etype,keyword,linenum) envtype etype; char *keyword; long linenum;
  791.  
  792. /* push an environment onto the stack */
  793.  
  794. {
  795.   if (++Lex_TOS >= MAX_ENTRIES) {
  796.      fprintf(stderr,"Stack overflow...Process terminating.\n");
  797.      texit();
  798.   }
  799.   Lex_Stack[Lex_TOS].etype = etype;
  800.   Lex_Stack[Lex_TOS].keyword = keyword;
  801.   Lex_Stack[Lex_TOS].linenum = linenum;
  802. }
  803.  
  804.  
  805. lex_pop (ptr_etype,ptr_keyword,ptr_linenum)
  806.  
  807. /* pop an environment and return its components */
  808.  
  809.   envtype *ptr_etype;
  810.   char **ptr_keyword;
  811.   long *ptr_linenum;
  812.  
  813. {
  814.   if (Lex_TOS < 0) {
  815.      fprintf(stderr,"Stack underflow...Process terminating\n");
  816.      texit();
  817.   }
  818.   *ptr_etype = Lex_Stack[Lex_TOS].etype;
  819.   *ptr_keyword = Lex_Stack[Lex_TOS].keyword;
  820.   *ptr_linenum = Lex_Stack[Lex_TOS].linenum;
  821.   Lex_TOS--;
  822. }
  823.  
  824.  
  825. curstack (ptr_etype,ptr_keyword,ptr_linenum)
  826.  
  827.   /* get the components of the current stack entry, but leave the entry */
  828.   /* on the stack. */
  829.  
  830.   envtype *ptr_etype;
  831.   char **ptr_keyword;
  832.   long *ptr_linenum;
  833.  
  834. {
  835.   if (Stack_Empty) {
  836.      fprintf(stderr,"Fatal error, bad call to curstack\n");
  837.      texit();
  838.   }
  839.   lex_pop(ptr_etype,ptr_keyword,ptr_linenum);
  840.   lex_push(*ptr_etype,*ptr_keyword,*ptr_linenum);
  841. }
  842.  
  843.  
  844. char *copy_keyword (starttoken,endtoken) int starttoken,endtoken;
  845.  
  846. /* grab a keyword from the Line_Buffer and copy it into a static buffer */
  847.  
  848. {
  849.   int len;
  850.   if (MAX_KEYWORD_LENGTH <= (len = (endtoken - starttoken) + 1)) {
  851.      keyword_length_error();
  852.      texit();
  853.   }
  854.   strncpy(Keyword_Buffer,Line_Buffer + starttoken,len);
  855.   Keyword_Buffer[len] = '\0';
  856.   return(Keyword_Buffer);
  857. }
  858.  
  859.  
  860. do_pop (etype,keyword) envtype etype; char *keyword;
  861.  
  862. /* make sure that the current environment is the matching begin-environment */
  863. /* for the end-environment that we have just discovered.  If so, pop the */
  864. /* environment off the stack.   If not its an error. */
  865.  
  866. {
  867.         
  868.   envtype oldetype;
  869.   char *oldkeyword;
  870.   long oldlinenum;
  871.   char *s, *e;
  872.         
  873.   lex_pop(&oldetype,&oldkeyword,&oldlinenum);
  874.         
  875.   switch (etype) {
  876.      
  877.     case ESCAPE_END :
  878.       s = "\\begin";
  879.       e = "\\end";
  880.       if (oldetype != ESCAPE_BEGIN) goto nesterror;
  881.       if (0 != strcmp(oldkeyword,keyword)) goto nesterror;
  882.       break;
  883.  
  884.     case RIGHT_SQUARE_BRACKET :
  885.       s = "[";
  886.       e = "]";
  887.       if (oldetype != LEFT_SQUARE_BRACKET) goto nesterror;
  888.       break;
  889.  
  890.     case RIGHT_CURLY_BRACKET :
  891.       s = "{";
  892.       e = "}";
  893.       if (oldetype != LEFT_CURLY_BRACKET) goto nesterror;
  894.       break;
  895.  
  896.     case MATH :
  897.       s = "Begin Math Mode";
  898.       e = "End Math Mode";
  899.       if (oldetype != etype) goto nesterror;
  900.       break;
  901.       
  902.     case DOUBLE_MATH :
  903.       s = "Begin Display Math Mode";
  904.       e = "End Display Math Mode";
  905.       if (oldetype != etype) goto nesterror;
  906.       break;
  907.  
  908.   }
  909.  
  910.   return(0);
  911.  
  912.   nesterror:
  913.  
  914.   nest_error(s,e,oldlinenum,oldkeyword);
  915.   texit();
  916.  
  917. }
  918.  
  919.  
  920. int get_a_char ()
  921.  
  922. /* buffered input routine, to keep track of line number */
  923.  
  924. {
  925.   int ch,rval;
  926.   if (Current_Char >= Line_Length) {
  927.      switch (rval = getline(fp,Line_Buffer,MAXLL-2)) {
  928.        case AT_EOF:
  929.          return(EOF);
  930.          break;
  931.        case TOO_MANY_CHARS :
  932.          line_too_long_error();
  933.          texit();
  934.          break;
  935.        default :
  936.          Line_Buffer[rval] = '\n';
  937.          Line_Buffer[++rval] = '\0';
  938.          Line_Length = rval;
  939.          Current_Char = 0;
  940.          Current_Line++;
  941.          break;
  942.      }
  943.   }
  944.   ch = (int) (255 & Line_Buffer[Current_Char++]);
  945.   if (!LGL_CHAR(ch)) bad_char_error(ch,T);
  946.   return(ch);
  947. }  
  948.   
  949.  
  950. unget_a_char ()
  951.  
  952. {
  953.   if (Current_Char == 0) {        
  954.      fprintf(stderr,"Invalid unget...process terminating\n");
  955.      texit();
  956.   }
  957.   Current_Char--;
  958. }  
  959.  
  960.  
  961. char *get_keyword ()
  962.  
  963. /* read a keyword.  Keywords consist of contiguous alphabetic characters */
  964. /* keyword returned is in a static buffer. */
  965.  
  966. {
  967.   int starttoken,endtoken,ch;
  968.   starttoken = Current_Char - 1;
  969.   endtoken = Current_Char - 1;
  970.   while (isalpha(ch = get_a_char())) {
  971.     endtoken++;
  972.   }
  973.   if (ch == EOF) {
  974.      Already_At_Eof = 1;
  975.   }
  976.   else unget_a_char();
  977.   return(copy_keyword(starttoken,endtoken));
  978. } 
  979.  
  980.  
  981. char *get_begin_end_keyword ()
  982.  
  983. /* called after a \begin or \end construct is found. */
  984. /* begin and end keywords are enclosed in {}. */
  985. /* a warning is issued if there is any whitespace within the {}s */
  986. /* returns a string constituting what is in between the {}s save for */
  987. /* whitespace immediately after the { and immediately before the } */
  988.  
  989. /* keyword returned is in a static buffer. */
  990.  
  991. {
  992.   int ch;        
  993.   int starttoken,endtoken;
  994.   
  995.   ch = get_a_char();
  996.   if (ch != LCB) {
  997.      no_brace_after_begin_end_error();
  998.      texit();
  999.   }
  1000.   
  1001.   starttoken = Current_Char;
  1002.   endtoken = starttoken - 1;
  1003.   while (RCB != (ch = get_a_char())) {
  1004.     if (ch == '\n')
  1005.        warning_close_brace();
  1006.     else if (ch == EOF) {
  1007.        eof_error();
  1008.        texit();
  1009.     }
  1010.     else 
  1011.        endtoken++;
  1012.   }
  1013.   
  1014.   /* ignore whitespace after '{' and before '}' */
  1015.   
  1016.   if (ISWHITE(Line_Buffer[starttoken]) || ISWHITE(Line_Buffer[endtoken])) {
  1017.      warning_blanks_in_cb();
  1018.   }
  1019.   
  1020.   while (starttoken < endtoken && ISWHITE(Line_Buffer[starttoken]))
  1021.     starttoken++;
  1022.   if (starttoken >= endtoken) {
  1023.      blank_begin_end_error();
  1024.      texit();
  1025.   }
  1026.   while (endtoken > starttoken && ISWHITE(Line_Buffer[endtoken]))
  1027.     endtoken--;
  1028.   return(copy_keyword(starttoken,endtoken));
  1029.   
  1030. }  
  1031.  
  1032.  
  1033. get_token (action,etype,keyword) 
  1034.  
  1035.   /* get the next significant token from the input stream. Based on its type */
  1036.   /* an action to perform is computed.  The significant part of the token is */
  1037.   /* returns in *keyword, which points to a static buffer. */
  1038.  
  1039.   /* returns 0 on encountering EOF, otherwise returns 1. */
  1040.  
  1041.   Actions *action;
  1042.   envtype *etype;
  1043.   char **keyword;
  1044.  
  1045. {  
  1046.   int ch,isbegin,isend;
  1047.   
  1048.   *keyword = 0;
  1049.   if (Already_At_Eof) return(0);
  1050.   
  1051.   readloop:
  1052.   
  1053.   if (EOF == (ch = get_a_char())) return(0);
  1054.  
  1055.   switch (ch) {
  1056.  
  1057.     case LSB :
  1058.       *etype = LEFT_SQUARE_BRACKET;
  1059.       *action = PUSH;
  1060.       *keyword = "[";
  1061.       return(1);
  1062.  
  1063.     case RSB :
  1064.       *etype = RIGHT_SQUARE_BRACKET;
  1065.       *action = POP;
  1066.       *keyword = "]";
  1067.       return(1);
  1068.  
  1069.     case LCB :
  1070.       *etype = LEFT_CURLY_BRACKET;
  1071.       *action = PUSH;
  1072.       *keyword = "{";
  1073.       return(1);
  1074.  
  1075.     case RCB :
  1076.       *etype = RIGHT_CURLY_BRACKET;
  1077.       *action = POP;
  1078.       *keyword = "}";
  1079.       return(1);
  1080.  
  1081.     case MATH_CHAR :
  1082.     
  1083.       /* Is the next character also a '$'? If so this is 'Display Math Mode' */
  1084.     
  1085.       if (EOF == (ch = get_a_char())) {
  1086.          *action = DOLLAR;
  1087.          *etype = MATH;
  1088.          *keyword = "$";
  1089.          Already_At_Eof = 1;
  1090.       }
  1091.       else if (ch == MATH_CHAR) {
  1092.          *action = DOLLAR_DOLLAR;
  1093.          *etype = DOUBLE_MATH;
  1094.          *keyword = "$$";
  1095.       }
  1096.       else {
  1097.          unget_a_char();
  1098.          *action = DOLLAR;
  1099.          *etype = MATH;
  1100.          *keyword = "$";
  1101.       }
  1102.       return(1);
  1103.  
  1104.     case ESCAPE :
  1105.     
  1106.       /* treat specially \begin and \end */
  1107.     
  1108.       if (EOF == (ch = get_a_char())) {
  1109.          eof_error();
  1110.          texit();
  1111.       }
  1112.       
  1113.       /* first check for single character non-alphabetic commands */
  1114.       
  1115.       if (!isalpha(ch)) {
  1116.          *action = CHECK_SINGLE;
  1117.          *etype = ESCAPE_SINGLE_CHAR;
  1118.          Keyword_Buffer[0] = ch;
  1119.          Keyword_Buffer[1] = '\0';
  1120.          *keyword = Keyword_Buffer;
  1121.          return(1);
  1122.       }
  1123.         
  1124.         
  1125.       *keyword = get_keyword();
  1126.       isbegin = (0 == strcmp(*keyword,BEGINSTRING));
  1127.       isend = (0 == strcmp(*keyword,ENDSTRING));
  1128.       if (!isbegin && !isend) {
  1129.          *action = CHECK;
  1130.          *etype = ESCAPE_ANY;
  1131.          return(1);
  1132.       }
  1133.       
  1134.       *etype = isbegin ? ESCAPE_BEGIN : ESCAPE_END;
  1135.       *action = isbegin ? PUSH : POP;
  1136.       *keyword = get_begin_end_keyword();
  1137.       return(1);
  1138.  
  1139.     case COMMENT :
  1140.     
  1141.       /* just read in the rest of the line and ignore what's on it */
  1142.     
  1143.       while ('\n' != (ch = get_a_char())) {
  1144.         if (EOF == ch) return(0);
  1145.       }
  1146.       goto readloop;
  1147.     
  1148.     default :
  1149.       goto readloop;
  1150.       
  1151.   }
  1152.  
  1153. }
  1154.  
  1155. push_math_mode (key) char *key;
  1156. {
  1157.   if (Verbose_Mode) {
  1158.      do_indent(Indent_Level++);
  1159.      fprintf (
  1160.          stderr,"Line %d: Entering math mode using <%s>\n",Current_Line,key
  1161.        );
  1162.   }
  1163.   Math_Mode_Depth++;
  1164.   In_Math_Mode = T;
  1165.   lex_push(MATH,key,Current_Line);
  1166. }
  1167.  
  1168. pop_math_mode (key) char *key;
  1169. {
  1170.   envtype etype;
  1171.   char *keyword;
  1172.   long linenum;
  1173.   if (Verbose_Mode) {
  1174.      do_indent(--Indent_Level);
  1175.      fprintf (
  1176.          stderr,"Line %d: Leaving math mode using <%s>\n",Current_Line,key
  1177.        );
  1178.   }
  1179.   Math_Mode_Depth--;
  1180.   In_Math_Mode = (Math_Mode_Depth > 0);
  1181.   lex_pop(&etype,&keyword,&linenum);
  1182. }
  1183.  
  1184.  
  1185. math_mode_action (action,keyword) Actions action; char *keyword;
  1186.  
  1187. /* check for math mode tokens, and enter or leave math mode as appropriate */
  1188.  
  1189. {
  1190.   char *stack_keyword;
  1191.   long linenum;
  1192.   envtype etype;
  1193.   char *key, *matching_keyword;
  1194.   
  1195.   switch (action) {
  1196.  
  1197.     /* If there is a matching '$' or '$$' as the latest entry on the stack */
  1198.     /* we pop it because it is a matching token.  Otherwise, we push it, */
  1199.     /* even if we are already in math mode. */
  1200.         
  1201.     case (DOLLAR) :
  1202.     case (DOLLAR_DOLLAR) :
  1203.       key = (action == DOLLAR) ? "$" : "$$";
  1204.       if (!In_Math_Mode) {
  1205.          push_math_mode(key);
  1206.          break;
  1207.       }
  1208.       curstack(&etype,&stack_keyword,&linenum);
  1209.       if (0 != strcmp(key,stack_keyword)) {
  1210.          push_math_mode(key);
  1211.       }
  1212.       else {
  1213.          pop_math_mode(key);
  1214.       }
  1215.       break;
  1216.      
  1217.     /* just adjust Math Mode for PUSH and POP, because in process_file */
  1218.     /* we will do the actual pushing and popping of these environments. */
  1219.       
  1220.     case (PUSH) :
  1221.       if (is_math_environment(keyword)) {
  1222.          Math_Mode_Depth++;
  1223.          In_Math_Mode = T;
  1224.       }
  1225.       break;
  1226.  
  1227.     case (POP) :
  1228.       if (is_math_environment(keyword)) {
  1229.          Math_Mode_Depth--;
  1230.          In_Math_Mode = (Math_Mode_Depth == 0);
  1231.       }
  1232.       break;
  1233.       
  1234.     /* look for \( and \[ commands which put us into math mode, and \) and */
  1235.     /* \] commands which pop us out of math mode.   Make sure if we are */
  1236.     /* popping that the proper pushed math mode command is the current */
  1237.     /* stack entry. */
  1238.       
  1239.     case (CHECK_SINGLE) :
  1240.       if (*keyword == '(' || *keyword == '[') {
  1241.          push_math_mode(anewstr(keyword));
  1242.       }
  1243.       else if (*keyword == ')' || *keyword == ']') {
  1244.          if (Stack_Empty) {
  1245.             stack_empty_error(MATH,keyword);
  1246.             texit();
  1247.          }
  1248.          curstack(&etype,&stack_keyword,&linenum);
  1249.          matching_keyword = (*keyword == ')') ? "(" : "[";
  1250.          if (0 != strcmp(matching_keyword,stack_keyword)) {
  1251.             nest_error(matching_keyword,keyword,linenum,stack_keyword);
  1252.             texit();
  1253.          }
  1254.          pop_math_mode(keyword);
  1255.       }
  1256.       break;
  1257.  
  1258.   }
  1259.  
  1260. }
  1261.  
  1262.  
  1263. process_file () 
  1264.  
  1265. /* Get significant LaTeX forms from the input file.  For each one, depending */
  1266. /* on its nature perform a verification or manipulate the environment stack. */
  1267. /* When we are done the stack should be empty. */
  1268.  
  1269. /* The file has already been opened using the global file descriptor 'fp' */
  1270.  
  1271. {
  1272.   Actions action;          
  1273.   envtype etype;
  1274.   char *keyword;
  1275.   int cmd_index,ch;
  1276.         
  1277.   while (0 != get_token(&action,&etype,&keyword)) {
  1278.  
  1279.     switch (action) {
  1280.  
  1281.       case (POP) :
  1282.  
  1283.         /* \end{keyword},, '}', ']' */
  1284.       
  1285.         if (Stack_Empty) {
  1286.            stack_empty_error(etype,keyword);
  1287.            texit();
  1288.         }
  1289.         
  1290.         math_mode_action(POP,keyword);
  1291.       
  1292.         if (Verbose_Mode && *keyword != '}' && *keyword != ']') {
  1293.            do_indent(--Indent_Level);
  1294.            printf("line %d: \\end{%s}\n",Current_Line,keyword);
  1295.         }
  1296.         do_pop(etype,keyword);
  1297.         break;
  1298.  
  1299.       case (PUSH) :
  1300.       
  1301.         /* \begin{keyword}, '{', '[' */
  1302.       
  1303.         math_mode_action(PUSH,keyword);
  1304.       
  1305.         if (Verbose_Mode && *keyword != '{' && *keyword != '[') {
  1306.            do_indent(Indent_Level++);
  1307.            printf("line %d: \\begin{%s}\n",Current_Line,keyword);
  1308.         }
  1309.         
  1310.         if (0==strcmp("verbatim",keyword) || 0==strcmp("verbatim*",keyword)) {
  1311.            do_verbatim(keyword);
  1312.            break;
  1313.         }
  1314.         else {
  1315.            lex_push(etype,anewstr(keyword),Current_Line);
  1316.            break;
  1317.         }
  1318.  
  1319.       case (DOLLAR) :
  1320.         math_mode_action(DOLLAR,keyword);
  1321.         break;
  1322.         
  1323.       case (DOLLAR_DOLLAR) :
  1324.         math_mode_action(DOLLAR_DOLLAR,keyword);
  1325.         break;
  1326.       
  1327.       case (CHECK_SINGLE) :
  1328.  
  1329.         /* check for \(, \[, \), \] for math mode */
  1330.       
  1331.         math_mode_action(CHECK_SINGLE,keyword);
  1332.         
  1333.         if (Check_Mode) {
  1334.            if (!LGL_SINGLE_COMMAND_CHAR(*keyword)) {
  1335.               single_char_command_error(*keyword);
  1336.            }
  1337.            if (NOT_FOUND == (cmd_index = command_lookup(keyword))) {
  1338.               fprintf(stderr,"Fatal error:\n");
  1339.               fprintf(stderr,"Command Table and Legal Chars out of sync\n");
  1340.               exit(1);
  1341.            }
  1342.            if (!In_Math_Mode && IS_MATH_MODE(cmd_index)) {
  1343.               math_keyword_error(keyword);
  1344.            }
  1345.               
  1346.         }
  1347.         break;
  1348.         
  1349.       case (CHECK) :
  1350.       
  1351.         /* \command token */
  1352.       
  1353.         if (0 == strcmp("verb",keyword)) {
  1354.            if ('*' != (ch = get_a_char())) unget_a_char();
  1355.            do_verb();
  1356.            break;
  1357.         }
  1358.       
  1359.         if (Check_Mode) {
  1360.            if (NOT_FOUND == (cmd_index = command_lookup(keyword))) {
  1361.               keyword_error(keyword);
  1362.            }
  1363.            else if (!In_Math_Mode && IS_MATH_MODE(cmd_index)) {
  1364.               math_keyword_error(keyword);
  1365.            }
  1366.         }
  1367.         
  1368.         break;
  1369.         
  1370.       default :
  1371.         fprintf(stderr,"Invalid return from get_token...\n");
  1372.         texit();
  1373.         
  1374.     }
  1375.  
  1376.   }
  1377.     
  1378.   if (!Stack_Empty) {
  1379.      eof_error();
  1380.      texit();
  1381.   }
  1382.  
  1383.   return(0);
  1384.  
  1385. }
  1386.  
  1387.  
  1388. texit ()
  1389. {
  1390.   fclose(fp);
  1391.   exit(1);
  1392. }
  1393.  
  1394.  
  1395. usage () 
  1396. {
  1397.   fprintf(stderr,"\nUnrecognized argument to texchk\n");
  1398.   fprintf(stderr,"Usage: texchk [ -v -c ] [ file1 file2 ... ]\n");
  1399.   exit(1);
  1400. }
  1401.   
  1402.   
  1403. main (argc,argv) int argc; char **argv;
  1404.  
  1405. {
  1406.   char **argptr;        
  1407.   int j,input_files = 0;
  1408.         
  1409.   init_legal_chars();
  1410.   
  1411.   /* process command line arguments */
  1412.   
  1413.   argptr = argv;        
  1414.   while (*++argptr != 0) {
  1415.     if (**argptr == '-') {
  1416.        if (strlen(*argptr) != 2) { 
  1417.           usage();
  1418.        }
  1419.        switch ((*argptr)[1]) {
  1420.          case 'v' :
  1421.            Verbose_Mode = T;
  1422.            break;
  1423.          case 'c' :
  1424.            Check_Mode = T;
  1425.            break;
  1426.          default :
  1427.            usage();
  1428.            break;
  1429.        }
  1430.        *argptr = '\0';
  1431.     }
  1432.     else input_files = 1;
  1433.   }
  1434.         
  1435.   /* read and process each file */
  1436.   
  1437.   if (!input_files) {
  1438.      printf("\n");
  1439.      fp = stdin;
  1440.      process_file();
  1441.      printf("\nOK!\n\n");
  1442.   }  
  1443.   else {
  1444.     for (j = 1; j < argc; j++) {
  1445.         if (argv[j] != '\0') {
  1446.            printf("\nChecking file %s.\n\n",argv[j]);
  1447.            new_file();
  1448.            fp = (FILE *) efopen(argv[j],"r");
  1449.            process_file();
  1450.            fclose(fp);
  1451.         }
  1452.     }
  1453.  }
  1454.   
  1455.  exit(0);
  1456.  
  1457. }
  1458.  
  1459.  
  1460. SHAR_EOF
  1461. if test 16712 -ne "`wc -c < 'texchk.c'`"
  1462. then
  1463.     echo shar: error transmitting "'texchk.c'" '(should have been 16712 characters)'
  1464. fi
  1465. fi
  1466. exit 0
  1467. #    End of shell archive
  1468.